{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 函数式接口、lambda表达式和Stream流式编程\n",
    "\n",
    "*在Java中，**函数式接口**、**Lambda表达式**和**Stream流式编程**是**Java 8及更高版本**中引入的重要特性，它们共同支持了更简洁、更灵活的编程方式，特别是在处理集合和并发编程方面。下面分别介绍这三个概念：*\n",
    "\n",
    "## 函数式接口（Functional Interfaces）\n",
    "\n",
    "在Java中，函数式接口是指那些只包含一个抽象方法的接口（除了`Object`类中的方法,在接口中声明的方法默认是抽象的）。这样的接口可以与Lambda表达式结合使用，提供简洁的代码表示方式。函数式接口可以使用`@FunctionalInterface`注解进行标记，但这不是强制的。只要接口只包含一个抽象方法，虚拟机会自动判断该接口为函数式接口。一般建议在接口上使用@FunctionalInterface 注解进行声明，这样的话，编译器如果发现你标注了这个注解的接口有多于一个抽象方法的时候会报错"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 常见的函数式接口\n",
    "Java标准库中提供了多种类型的函数式接口，以下是其中一些常见的类型：\n",
    "\n",
    "1. **Function<T,R>**\n",
    "   - 位于`java.util.function`包下。\n",
    "   - 接受一个输入参数T，并产生一个结果R。\n",
    "   - 主要方法是`apply(T t)`。\n",
    "   - 用于表示一个函数，该函数接受一个参数并返回一个结果。\n",
    "\n",
    "2. **Consumer<T>**\n",
    "   - 位于`java.util.function`包下。\n",
    "   - 接受一个输入参数T，但不返回任何结果（void）。\n",
    "   - 主要方法是`accept(T t)`。\n",
    "   - 用于表示一个操作，该操作接受单个输入参数并且不返回结果。\n",
    "\n",
    "3. **Predicate<T>**\n",
    "   - 位于`java.util.function`包下。\n",
    "   - 接受一个输入参数T，并返回一个布尔值结果。\n",
    "   - 主要方法是`test(T t)`。\n",
    "   - 用于表示一个断言函数，该函数接受一个参数并根据条件返回true或false。\n",
    "\n",
    "4. **Supplier<T>**\n",
    "   - 位于`java.util.function`包下。\n",
    "   - 不接受任何输入参数，但返回一个结果T。\n",
    "   - 主要方法是`get()`。\n",
    "   - 用于表示一个供应商，该供应商提供值。\n",
    "\n",
    "5. **Runnable**\n",
    "   - 位于`java.lang`包下，尽管它不是一个`java.util.function`包下的接口，但它也是一个函数式接口。\n",
    "   - 不接受任何输入参数，也不返回任何结果（void）。\n",
    "   - 主要方法是`run()`。\n",
    "   - 通常用于表示一个任务或操作，该任务或操作可以被新线程执行，或者简单地执行一些操作而不返回结果。\n",
    "\n",
    "6. **Comparator<T>**\n",
    "   - 位于`java.util`包下，尽管它包含多个方法，但只有一个抽象方法`compare(T o1, T o2)`，因此它也可以被视为函数式接口（尽管它不是`java.util.function`包下的）。\n",
    "   - 用于表示一个比较器，该比较器定义了两个输入参数之间的自然顺序。\n",
    "\n",
    "需要注意的是，虽然`Comparator`接口在`java.util`包下，并且包含了多个方法，但根据Java语言规范，只有其`compare`方法是抽象的，并且被视为函数式接口的关键方法。其他方法（如`equals`、`hashCode`等）是从`Object`类继承的，或者是在`Comparator`接口中作为默认方法提供的，因此它们不计入抽象方法的计数中。\n",
    "\n",
    "此外，Java标准库中还包含了许多其他函数式接口，它们被设计用于特定的用途，如`UnaryOperator<T>`（一元操作符）、`BinaryOperator<T>`（二元操作符）、`ToIntFunction<T>`（将输入映射到int的函数）等，这些接口都位于`java.util.function`包下。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 函数式接口的示例：\n",
    "1. Function<T, R>\n",
    "作用：Function<T, R>接口表示一个接受一个输入参数T并产生结果R的函数。它主要用于类型转换、数据映射等场景。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO WORLD\n"
     ]
    }
   ],
   "source": [
    "import java.util.function.Function;\n",
    "\n",
    "public class FunctionExample {\n",
    "    public static void main(String[] args) {\n",
    "        // 创建一个Function接口实例，将字符串转换为大写  “::” 被称为引用操作符，它用于获取类或对象的方法的引用，也就是我们常说的方法引用（Method Reference）。方法引用是一种简化Lambda表达式的语法糖，使得代码更加简洁易读。\n",
    "        Function<String, String> toUpperCaseFunction = String::toUpperCase;\n",
    "        // 使用Function接口实例进行转换\n",
    "        String result = toUpperCaseFunction.apply(\"hello world\");\n",
    "        System.out.println(result); // 输出: HELLO WORLD\n",
    "    }\n",
    "}\n",
    "\n",
    "// [IJava] 调用main函数，查看 main()函数执行结果 在Jupyter notebook中的输出信息\n",
    "FunctionExample.main(new String[] {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 在Notebook中通过IJava内核运行Java程序需要注意的信息\n",
    "使用 Jupyter Notebook 配合 IJava 内核来运行 Java 程序时，main 函数的输出没有显示在 Notebook 中。\n",
    "这通常是因为 Java 程序的标准输出（stdout）和错误输出（stderr）的处理方式与 Python 在 Jupyter 中有所不同。\n",
    "在 Java 中，当你运行一个包含 main 方法的类时，这个方法默认是设计来独立运行的，而不是直接作为脚本的一部分在 Jupyter Notebook 中执行。\n",
    "\n",
    "``` java\n",
    "// [IJava] 调用main函数，查看 main() 在Jupyter notebook中的输出信息\n",
    "ClassName.main(new String[] {})\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Consumer<T>\n",
    "作用：Consumer<T>接口表示一个接受单个输入参数但不返回结果的操作。它主要用于执行一些操作，如打印、写入文件等。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Consumer!\n",
      "Hello again!\n",
      "HELLO AGAIN!\n"
     ]
    }
   ],
   "source": [
    "import java.util.function.Consumer;\n",
    "\n",
    "public class ConsumerExample {\n",
    "    public static void main(String[] args) {\n",
    "        // 创建一个Consumer接口实例，用于打印字符串\n",
    "        Consumer<String> printConsumer = System.out::println;\n",
    "\n",
    "        // 使用Consumer接口实例进行打印\n",
    "        printConsumer.accept(\"Hello, Consumer!\");\n",
    "\n",
    "        // 也可以链式调用Consumer接口的默认方法andThen\n",
    "        Consumer<String> upperCaseAndPrint = str -> System.out.println(str.toUpperCase());\n",
    "        Consumer<String> printConsumerChain = printConsumer.andThen(upperCaseAndPrint);\n",
    "        printConsumerChain.accept(\"Hello again!\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// [IJava] 调用main函数，查看 main() 在Jupyter notebook中的输出信息\n",
    "ConsumerExample.main(new String[] {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Predicate<T>\n",
    "作用：Predicate<T>接口表示一个接受输入参数并返回布尔值结果的断言函数。它主要用于条件判断。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "banana\n",
      "cherry\n"
     ]
    }
   ],
   "source": [
    "import java.util.Arrays;\n",
    "import java.util.List;\n",
    "import java.util.function.Predicate;\n",
    "\n",
    "public class PredicateExample {\n",
    "    public static void main(String[] args) {\n",
    "        List<String> strings = Arrays.asList(\"apple\", \"banana\", \"cherry\");\n",
    "\n",
    "        // 创建一个Predicate接口实例，检查字符串长度是否大于5\n",
    "        Predicate<String> isLongerThanFive = str -> str.length() > 5;\n",
    "\n",
    "        // 使用Predicate接口实例进行过滤\n",
    "        strings.stream()\n",
    "            .filter(isLongerThanFive)\n",
    "            .forEach(System.out::println); // 输出: banana\n",
    "    }\n",
    "}\n",
    "\n",
    "PredicateExample.main(new String[] {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Supplier<T>\n",
    "作用：Supplier<T>接口表示一个不接受任何输入参数并返回结果T的供应商。它主要用于延迟计算或按需生成值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "63\n",
      "89\n"
     ]
    }
   ],
   "source": [
    "import java.util.function.Supplier;\n",
    "\n",
    "public class SupplierExample {\n",
    "    public static void main(String[] args) {\n",
    "        // 创建一个Supplier接口实例，按需生成一个随机整数\n",
    "        Supplier<Integer> randomNumberSupplier = () -> (int) (Math.random() * 100);\n",
    "\n",
    "        // 多次调用get()方法获取不同的值\n",
    "        System.out.println(randomNumberSupplier.get());\n",
    "        System.out.println(randomNumberSupplier.get());\n",
    "    }\n",
    "}\n",
    "\n",
    "SupplierExample.main(new String [] {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Runnable\n",
    "尽管Runnable接口位于java.lang包下，并非java.util.function包中的一部分，但它同样是一个函数式接口。\n",
    "作用：Runnable接口表示一个无参数且无返回值的操作，通常用于创建线程任务。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running a task in a new thread\n"
     ]
    }
   ],
   "source": [
    "public class RunnableExample implements Runnable {\n",
    "    @Override\n",
    "    public void run() {\n",
    "        System.out.println(\"Running a task in a new thread\");\n",
    "    }\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        Thread thread = new Thread(new RunnableExample());\n",
    "        thread.start();\n",
    "\n",
    "        // 使用Lambda表达式简化\n",
    "        new Thread(() -> System.out.println(\"Lambda task in a new thread\")).start();\n",
    "    }\n",
    "}\n",
    "\n",
    "RunnableExample.main(new String [] {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. Comparator<T>接口是Java中用于定义对象排序规则的接口。尽管它包含了多个方法（如equals, hashCode, reversed(), thenComparing()等），但只有一个抽象方法compare(T o1, T o2)，因此它可以被视为函数式接口。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[date, apple, banana, cherry]\n",
      "[banana, cherry, apple, date]\n",
      "[date, apple, banana, cherry]\n"
     ]
    }
   ],
   "source": [
    "import java.util.Arrays;\n",
    "import java.util.Comparator;\n",
    "import java.util.List;\n",
    "\n",
    "public class ComparatorExample {\n",
    "    public static void main(String[] args) {\n",
    "        List<String> strings = Arrays.asList(\"banana\", \"apple\", \"cherry\", \"date\");\n",
    "\n",
    "        // 使用Lambda表达式创建Comparator实例，按字符串长度排序\n",
    "        Comparator<String> byLength = (s1, s2) -> Integer.compare(s1.length(), s2.length());\n",
    "\n",
    "        // 使用Collections.sort（或List.sort在Java 8+）和Comparator进行排序\n",
    "        strings.sort(byLength);\n",
    "\n",
    "        // 打印排序后的列表\n",
    "        System.out.println(strings); // 输出可能是：[apple, date, banana, cherry]，但顺序可能因Java版本和JVM实现而异\n",
    "\n",
    "        // 如果你想要逆序排序，可以使用Comparator.reversed()\n",
    "        strings.sort(byLength.reversed());\n",
    "\n",
    "        // 再次打印排序后的列表\n",
    "        System.out.println(strings); // 输出可能是：[cherry, banana, date, apple]，但顺序同样可能因实现而异\n",
    "\n",
    "        // 你还可以链式调用Comparator来定义更复杂的排序逻辑\n",
    "        // 比如，首先按长度排序，如果长度相同，则按字典顺序排序\n",
    "        strings.sort(Comparator.comparingInt(String::length)\n",
    "                               .thenComparing(String::compareTo));\n",
    "\n",
    "        // 打印最终排序后的列表\n",
    "        System.out.println(strings); // 输出应该是：[apple, date, banana, cherry]，因为apple和date长度相同，但apple字典序在前\n",
    "    }\n",
    "}\n",
    "\n",
    "ComparatorExample.main(new String[] {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambda表达式\n",
    "Lambda表达式是Java 8引入的一项重要功能，\n",
    "可以把Lambda表达式看作是一种更方便的匿名函数（即没有名称的方法），Lambda表达式特别适用于实现只有一个抽象方法的接口，即函数式接口。这意味着可以将函数作为参数传递给其他方法，使得代码更加灵活和可扩展。\n",
    "\n",
    "### Lambda表达式的语法\n",
    "> **基本语法:**  \n",
    ">   **(parameters) -> expression  \n",
    ">   或  \n",
    ">   (parameters) ->{ statements; }**\n",
    "\n",
    "**Lambda表达式由三部分组成：**\n",
    "- **paramaters：** 括号内是 lambda 表达式的参数列表。如果只有一个参数且类型可以推断出，可以省略括号。\n",
    "- **->：** Lambda操作符，用于分隔参数列表和方法体，可理解为“被用于”的意思。\n",
    "- **experssion：** 一个单一表达式，表示 lambda 表达式的返回值。\n",
    "- **statements：** 如果需要多条语句，则需要使用大括号包裹语句块，并且需要显式使用 return 语句返回结果。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lambda表达式的示例**  \n",
    "假设我们有一个函数式接口Greeting，它定义了一个接受String参数并返回void的greet方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Alice!\n"
     ]
    }
   ],
   "source": [
    "@FunctionalInterface\n",
    "interface Greeting {\n",
    "    void greet(String name);\n",
    "}\n",
    "\n",
    "// 使用Lambda表达式来实现这个接口\n",
    "Greeting greeting = name -> System.out.println(\"Hello, \" + name + \"!\");\n",
    "\n",
    "// 使用Lambda表达式\n",
    "greeting.greet(\"Alice\"); // 输出: Hello, Alice!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda表达式的特点\n",
    "- 简洁性：Lambda表达式使代码更加简洁，易于阅读和维护。通过Lambda表达式，我们可以将复杂的逻辑简化为几行代码。\n",
    "- 函数式接口：Lambda表达式主要用于实现函数式接口的实例。函数式接口是只包含一个抽象方法的接口，Lambda表达式可以看作是该接口的一个匿名实现。\n",
    "- 类型推断：在Lambda表达式中，如果编译器能够根据上下文推断出参数的类型，那么可以省略参数的类型声明。\n",
    "- 语法灵活性：Lambda表达式在语法上提供了很大的灵活性。例如，如果Lambda表达式只接受一个参数，那么可以省略包围该参数的小括号；如果Lambda体只包含一条语句，那么可以省略大括号和分号；如果Lambda体中的唯一语句是一个返回语句，并且该语句的返回值类型与Lambda表达式声明的返回类型兼容，那么可以省略return关键字以及该语句后的分号。\n",
    "### Lambda表达式的应用场景\n",
    "Lambda表达式在Java中有广泛的应用场景，包括但不限于以下几个方面：\n",
    "\n",
    "- 集合操作：在Java的集合框架中，我们可以使用Lambda表达式对集合进行各种操作，如过滤、映射、排序等。\n",
    "多线程编程：Lambda表达式可以用于简化多线程编程。通过Lambda表达式，我们可以更方便地创建线程、定义线程的执行逻辑等。\n",
    "- GUI编程：在GUI编程中，Lambda表达式可以用于定义事件的处理逻辑，使代码更加简洁。\n",
    "- 函数式编程：Lambda表达式支持函数式编程的相关特性，如高阶函数、闭包等，使得Java能够支持更加灵活的编程范式。\n",
    "### Lambda表达式的注意事项\n",
    "虽然Lambda表达式可以使代码更加简洁，但过度使用可能会导致代码难以阅读和理解。因此，在使用Lambda表达式时，应遵循以下几点原则：\n",
    "\n",
    "- 确保Lambda表达式的逻辑简单明了：避免在Lambda表达式中编写复杂的逻辑，以保持代码的清晰易懂。\n",
    "- 合理使用参数名称和注释：通过合理的参数命名和必要的注释来增强代码的可读性。\n",
    "- 对于复杂逻辑，使用传统方法：如果Lambda表达式的逻辑过于复杂，难以理解和维护，那么可以考虑使用传统的方法来编写代码。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "source": [
    "### lambda 示例\n",
    "下面通过几个示例来说明**Lambda表达式的参数、方法体、返回值在不同情况下的表现，以及哪些部分可以省略。**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "source": [
    "**1. 单个参数且类型可推断**  \n",
    "当Lambda表达式只有一个参数，并且该参数的类型可以被编译器推断出来时，可以**省略参数的类型声明以及包围参数的小括号（如果参数列表不为空）**。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "banana\n",
      "cherry\n"
     ]
    }
   ],
   "source": [
    "List<String> list = Arrays.asList(\"apple\", \"banana\", \"cherry\");\n",
    "// 在循环中使用lambda表达式打印当前列表元素\n",
    "list.forEach(s -> System.out.println(s)); // s的类型被推断为String，小括号可以省略但通常保留以提高可读性"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2. 无参数**  \n",
    "如果Lambda表达式没有参数，那么需要**保留空的小括号**。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "// 使用 Lambda 表达式创建 Runnable 对象 (Runnable 是一个函数式接口，用于表示可以在线程中执行的任务。Runnable 接口包含一个方法 run()，当线程启动时会调用这个方法来执行任务。使用 Runnable 可以方便地创建线程并实现并发操作。)\n",
    "Runnable runnable = () -> System.out.println(\"Hello, Lambda!\"); // 无参数，需要空的小括号\n",
    "\n",
    "// 创建并启动线程\n",
    "Thread thread = new Thread(runnable);\n",
    "thread.start();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. 多个参数**  \n",
    "当Lambda表达式有多个参数时，**必须显式地声明它们，并且需要用小括号括起来**。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "banana: 200\n",
      "apple: 100\n"
     ]
    }
   ],
   "source": [
    "Map<String, Integer> map = new HashMap<>();  \n",
    "map.put(\"apple\", 100);  \n",
    "map.put(\"banana\", 200);  \n",
    "// 即使在多个参数的情况下，只要 lambda 表达式的目标类型能够提供足够的信息来推断参数类型，就可以省略参数类型。\n",
    "// map.forEach((String key, Integer value) -> System.out.println(key + \": \" + value)); // 多个参数，需要小括号\n",
    "map.forEach((key, value) -> System.out.println(key + \": \" + value)); // 多个参数，需要小括号"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4. 方法体只有一条语句**  \n",
    "如果Lambda表达式的方法体只有一条语句，那么**可以省略大括号和分号**。如果这条语句是返回语句，并且Lambda表达式的返回类型与语句的返回类型兼容，那么**还可以省略return关键字**。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "apple"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "List<String> strings = Arrays.asList(\"apple\", \"banana\", \"cherry\");  \n",
    "String firstFruit = strings.stream()  \n",
    "    .filter(s -> s.startsWith(\"a\")) // 过滤以'a'开头的字符串，只有一条语句，省略了大括号和分号  \n",
    "    .findFirst() // 找到第一个符合条件的元素  \n",
    "    .orElse(\"No fruit starts with 'a'\"); // 如果找不到，则返回\"No fruit starts with 'a'\"\n",
    "\n",
    "firstFruit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5. 方法体有多条语句**  \n",
    "如果Lambda表达式的方法体包含多条语句，那么**必须使用大括号将它们括起来，并且每条语句后需要分号**。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "APPLE!\n",
      "BANANA!\n",
      "CHERRY!\n"
     ]
    }
   ],
   "source": [
    "List<String> list = Arrays.asList(\"apple\", \"banana\", \"cherry\");  \n",
    "list.forEach(s -> {  \n",
    "    System.out.print(s.toUpperCase()); // 转换为大写  \n",
    "    System.out.println(\"!\"); // 添加感叹号  \n",
    "}); // 多条语句，需要大括号和分号"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**6. 返回值**  \n",
    "Lambda表达式的返回值取决于其实现的函数式接口的抽象方法的返回类型。如果Lambda表达式的方法体只有一条返回语句，并且该语句的返回类型与Lambda表达式的返回类型兼容，则**可以省略return关键字**。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);  \n",
    "int sum = numbers.stream()  \n",
    "    .map(n -> n * 2) // 将每个数字乘以2，返回int类型，省略了return  \n",
    "    .reduce(0, Integer::sum); // 累加结果，初始值为0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在这个例子中，`map`操作中的Lambda表达式`n -> n * 2`没有显式地使用`return`关键字，因为编译器知道`map`函数期望一个返回`int`的函数式接口实例，而`n * 2`的结果就是`int`类型，因此可以省略`return`。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 流式编程（Stream API）详解\n",
    "\n",
    "#### 1. 引入背景\n",
    "\n",
    "在Java 8之前，处理集合（如List、Set）中的元素通常需要通过循环（for-each、for循环等）和条件语句（if-else）来实现。这种方式在处理复杂的数据转换和过滤时，代码往往变得冗长且难以维护。Java 8引入的Stream API提供了一种更加高效、灵活且易于理解的方式来处理集合中的元素。\n",
    "\n",
    "#### 2. 核心概念\n",
    "\n",
    "- **流（Stream）**：流是Java 8中引入的一个关键抽象概念，它代表了一个来自数据源的元素队列并支持聚合操作。流操作分为**中间操作**和**终端操作**两种。\n",
    "\n",
    "- **中间操作**：中间操作是指那些返回一个新的Stream流对象的操作，，它们不会消耗Stream流，也不会产生最终的结果，而是可以链式地调用，形成一个操作管道。中间操作是惰性的，即它们不会立即执行，而是会等到终端操作时才执行。\n",
    "\n",
    "- **终端操作**：触发流的执行，产生一个最终的结果或者一个副作用的操作。一旦执行了终端操作，流就被消费了，无法再次使用。\n",
    "- 并行处理：Stream API支持并行处理，可以通过调用集合的parallelStream()方法获得并行流，以提高处理效率。\n",
    "- 延迟执行：Stream API的操作是延迟执行的，即中间操作不会立即执行，而是会等待终端操作时才执行整个操作管道。\n",
    "- 不改变源对象：Stream API的所有操作都不会改变源对象，而是返回一个新的Stream流对象或最终结果。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. 函数式接口与Lambda表达式\n",
    "\n",
    "在流式编程中，函数式接口和Lambda表达式是不可或缺的部分。函数式接口是只包含一个抽象方法的接口（可以有多个默认方法或静态方法），而Lambda表达式则是函数式接口的匿名实现。\n",
    "\n",
    "Stream API定义了大量的函数式接口来支持各种操作，如：\n",
    "\n",
    "1. **Predicate<T>**：这是一个用于测试某个条件是否满足的函数式接口。它定义了一个`test`方法，该方法接受一个输入参数并返回一个布尔值。常用于`filter`操作中。\n",
    "\n",
    "2. **Consumer<T>**：这是一个接受单个输入参数但不返回任何结果的操作，它对输入参数执行指定的操作。常用于`forEach`和`accept`操作中。\n",
    "\n",
    "3. **Function<T,R>**：这是一个将输入参数T映射到结果R的函数式接口。它定义了一个`apply`方法，该方法接受一个输入参数并返回相应的结果。常用于`map`操作中。\n",
    "\n",
    "4. **Supplier<T>**：这是一个不接受任何参数但返回一个结果的函数式接口。它定义了一个`get`方法，用于返回结果。常用于需要生成新对象或值的场景中。\n",
    "\n",
    "5. **UnaryOperator<T>**：这是`Function<T,T>`的一个特殊化接口，表示接受一个参数并返回相同类型结果的函数。\n",
    "\n",
    "6. **BinaryOperator<T>**：这是一个表示接受两个同类型参数并返回它们组合结果的函数式接口。它定义了一个`apply`方法，该方法接受两个输入参数并返回一个结果。常用于归约操作中，如`reduce`。\n",
    "\n",
    "7. **Comparator<T>**：这是一个用于比较两个对象的函数式接口。它定义了一个`compare`方法，该方法比较两个对象并返回一个整数来表示它们的顺序。虽然`Comparator`不是专门为Stream API设计的，但它在排序和比较操作中非常有用。\n",
    "\n",
    "8. **ToIntFunction<T>**、**ToLongFunction<T>**、**ToDoubleFunction<T>**：这些是`Function`接口的特殊化，分别用于返回`int`、`long`和`double`类型的值。\n",
    "\n",
    "9. **IntFunction<R>**、**LongFunction<R>**、**DoubleFunction<R>**：这些是`Function`接口的特殊化，它们的输入参数是`int`、`long`或`double`类型，并返回一个泛型结果`R`。\n",
    "\n",
    "10. **ObjIntConsumer<T>**、**ObjLongConsumer<T>**、**ObjDoubleConsumer<T>**：这些接口结合了`Consumer`和数值类型参数（`int`、`long`、`double`），用于对单个对象和一个数值进行操作。\n",
    "\n",
    "11. **BiConsumer<T,U>**：这是一个接受两个输入参数且没有返回值的函数式接口。虽然它不是Stream API特有的，但在需要对两个参数执行操作的场景中很有用。\n",
    "\n",
    "12. **BiFunction<T,U,R>**：这是一个将两个输入参数T和U映射到结果R的函数式接口。它定义了一个`apply`方法，该方法接受两个输入参数并返回一个结果。\n",
    "\n",
    "请注意，这里列出的只是Stream API中常用的一部分函数式接口。Java的`java.util.function`包中定义了许多其他函数式接口，它们可以与Stream API或其他Java 8及以上版本的函数式编程特性一起使用。这些接口提供了丰富的功能，支持各种复杂的操作和数据转换。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. 流式编程的基本步骤（详细）\n",
    "\n",
    "1. **创建流**：\n",
    "   - 通过调用集合的`stream()`方法创建顺序流。\n",
    "   - 通过调用集合的`parallelStream()`方法创建并行流（如果可用）。\n",
    "   - 通过数组：使用Arrays.stream(T[] array)方法。\n",
    "   - 通过Stream的of()方法：直接生成包含指定元素的Stream。\n",
    "   - 其他：如使用IntStream.range(int startInclusive, int endExclusive)等生成数字序列的Stream。\n",
    "\n",
    "2. **中间操作**（可选，可多个）：\n",
    "   - **过滤**：使用`filter(Predicate<? super T> predicate)`方法过滤流中的元素。\n",
    "   - **映射**：使用`map(Function<? super T,? extends R> mapper)`方法将流中的每个元素映射成另一种形式。\n",
    "   - **排序**：使用`sorted()`或`sorted(Comparator<? super T> comparator)`方法对流中的元素进行排序。\n",
    "   - **去重**：使用`distinct()`方法去除流中的重复元素（基于元素的`equals()`和`hashCode()`方法）。\n",
    "   - **截断**：使用`limit(long maxSize)`方法限制流中元素的数量。\n",
    "   - **跳过**：使用`skip(long n)`方法跳过流中的前n个元素。\n",
    "\n",
    "   - **其他**：如`peek(Consumer<? super T> action)`方法，主要用于调试目的，对流中的每个元素执行操作，但不改变流本身。\n",
    "\n",
    "3. **终端操作**（必须）：\n",
    "   - **遍历/消费**：使用`forEach(Consumer<? super T> action)`方法遍历流中的每个元素，并对其执行操作。\n",
    "   - **归约**：使用`reduce(BinaryOperator<T> accumulator)`方法将流中的元素组合起来，得到一个值。\n",
    "   - **收集**：使用`collect(Collectors.toList())`、`collect(Collectors.toSet())`等方法将流中的元素收集到新的集合中。\n",
    "   - **匹配**：使用`anyMatch(Predicate<? super T> predicate)`、`allMatch(Predicate<? super T> predicate)`、`noneMatch(Predicate<? super T> predicate)`等方法检查流中的元素是否满足某个条件。\n",
    "   - **查找**：使用`findFirst()`、`findAny()`等方法查找流中的元素。\n",
    "   - **最大值/最小值**：使用`max(Comparator<? super T> comparator)`、`min(Comparator<? super T> comparator)`方法找到流中的最大或最小元素。\n",
    "   - **计数**：使用`count()`方法计算流中的元素数量。\n",
    "\n",
    "\n",
    "> **关于Stream的更多信息可查看[Java API 中文文档](https://doc.qzxdp.cn/jdk/17/zh/api/java.base/java/util/stream/package-summary.html)**  \n",
    "> **[Java API 官方文档](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/stream/Stream.html)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stream API 示例"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1. 通过集合创建Stream并进行过滤和排序**  \n",
    "假设你有一个包含多个字符串的列表，你想要筛选出所有长度大于3的字符串，并按字典顺序排序。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Example, Java, Stream]\n"
     ]
    }
   ],
   "source": [
    "import java.util.ArrayList;\n",
    "import java.util.List;\n",
    "import java.util.stream.Collectors;\n",
    "\n",
    "public class StreamExample {\n",
    "    public static void main(String[] args) {\n",
    "        List<String> stringList = new ArrayList<>();\n",
    "        stringList.add(\"Java\");\n",
    "        stringList.add(\"Stream\");\n",
    "        stringList.add(\"API\");\n",
    "        stringList.add(\"Example\");\n",
    "\n",
    "        // 创建Stream\n",
    "        List<String> filteredAndSortedList = stringList.stream()\n",
    "            // 过滤操作：筛选出长度大于3的字符串\n",
    "            .filter(s -> s.length() > 3)\n",
    "            // 排序操作：按字典顺序排序\n",
    "            .sorted()\n",
    "            // 收集操作：将Stream转换为List\n",
    "            .collect(Collectors.toList());\n",
    "\n",
    "        System.out.println(filteredAndSortedList);\n",
    "        // 输出: [API, Example, Java, Stream]（注意：这里的输出假设排序不考虑大小写，实际输出可能因排序规则而异）\n",
    "    }\n",
    "}\n",
    "\n",
    "StreamExample.main(new String[] {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2. 使用Stream处理数组**  \n",
    "假设你有一个整型数组，你想要找出其中所有的偶数并求和。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "import java.util.Arrays;\n",
    "import java.util.stream.IntStream;\n",
    "\n",
    "public class StreamArrayExample {\n",
    "    public static void main(String[] args) {\n",
    "        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};\n",
    "\n",
    "        // 使用Arrays.stream()将数组转换为IntStream\n",
    "        int sumOfEvens = Arrays.stream(numbers)\n",
    "            // 过滤操作：筛选出偶数\n",
    "            .filter(n -> n % 2 == 0)\n",
    "            // 规约操作：求和\n",
    "            .sum();\n",
    "\n",
    "        System.out.println(sumOfEvens);\n",
    "        // 输出: 30\n",
    "    }\n",
    "}\n",
    "\n",
    "StreamArrayExample.main(new String [] {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. 无限流的创建和使用**  \n",
    "虽然无限流在实际应用中较少，但了解如何创建它们也是有益的。你可以使用Stream.iterate()或Stream.generate()来创建无限流。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "import java.util.stream.Stream;\n",
    "\n",
    "public class InfiniteStreamExample {\n",
    "    public static void main(String[] args) {\n",
    "        // 使用Stream.iterate()创建无限流，从1开始，每次增加1\n",
    "        Stream<Integer> infiniteStream = Stream.iterate(1, n -> n + 1);\n",
    "\n",
    "        // 注意：无限流不能直接使用collect()等方法收集，因为它没有终止条件\n",
    "        // 这里仅作为示例，展示如何获取流的前几个元素\n",
    "        infiniteStream.limit(5) // 限制流中元素的数量\n",
    "            .forEach(System.out::println);\n",
    "        // 输出: 1, 2, 3, 4, 5\n",
    "    }\n",
    "}\n",
    "\n",
    "InfiniteStreamExample.main(new String[] {});"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4. 映射和收集**  \n",
    "假设你有一个包含人员信息的列表，每个人员都是一个包含姓名和年龄的Person对象。你想要创建一个新列表，其中只包含人员的姓名（大写）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ALICE, BOB, CHARLIE]\n"
     ]
    }
   ],
   "source": [
    "import java.util.Arrays;  \n",
    "import java.util.List;  \n",
    "import java.util.stream.Collectors;  \n",
    "  \n",
    "public class Person {\n",
    "    // 成员变量\n",
    "    private String name;\n",
    "    private int age;\n",
    "\n",
    "    // 无参构造函数\n",
    "    public Person() {\n",
    "    }\n",
    "\n",
    "    // 带参构造函数\n",
    "    public Person(String name, int age) {\n",
    "        this.name = name;\n",
    "        this.age = age;\n",
    "    }\n",
    "\n",
    "    // Getter 方法：获取 name\n",
    "    public String getName() {\n",
    "        return name;\n",
    "    }\n",
    "\n",
    "    // Setter 方法：设置 name\n",
    "    public void setName(String name) {\n",
    "        this.name = name;\n",
    "    }\n",
    "\n",
    "    // Getter 方法：获取 age\n",
    "    public int getAge() {\n",
    "        return age;\n",
    "    }\n",
    "\n",
    "    // Setter 方法：设置 age\n",
    "    public void setAge(int age) {\n",
    "        this.age = age;\n",
    "    }\n",
    "}\n",
    "\n",
    "  \n",
    "public class StreamMapExample {  \n",
    "    public static void main(String[] args) {  \n",
    "        List<Person> people = Arrays.asList(  \n",
    "            new Person(\"Alice\", 30),  \n",
    "            new Person(\"Bob\", 25),  \n",
    "            new Person(\"Charlie\", 35)  \n",
    "        );  \n",
    "  \n",
    "        List<String> names = people.stream()  \n",
    "            .map(Person::getName) // 将Person对象映射为姓名字符串  \n",
    "            .map(String::toUpperCase) // 将姓名转换为大写  \n",
    "            .collect(Collectors.toList()); // 收集结果到新的List中  \n",
    "  \n",
    "        System.out.println(names); // 输出: [ALICE, BOB, CHARLIE]  \n",
    "    }  \n",
    "}\n",
    "\n",
    "StreamMapExample.main(new String[] {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5. 过滤和归约**  \n",
    "假设你有一个数字列表，你想要找到列表中所有偶数的和。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "import java.util.Arrays;  \n",
    "import java.util.List;  \n",
    "  \n",
    "public class StreamReduceExample {  \n",
    "    public static void main(String[] args) {  \n",
    "        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);  \n",
    "  \n",
    "        int sumOfEvens = numbers.stream()  \n",
    "            .filter(n -> n % 2 == 0) // 过滤出偶数  \n",
    "            .reduce(0, Integer::sum); // 从0开始归约求和  \n",
    "  \n",
    "        System.out.println(sumOfEvens); // 输出: 30  \n",
    "    }  \n",
    "}\n",
    "\n",
    "StreamReduceExample.main(new String[] {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**6. 扁平化和收集**  \n",
    "假设你有一个列表的列表，每个内部列表包含一些字符串。你想要创建一个新的列表，其中包含所有内部列表中的字符串。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Apple, Banana, Orange, Mango, Peach, Grape, Strawberry]\n"
     ]
    }
   ],
   "source": [
    "import java.util.Arrays;  \n",
    "import java.util.List;  \n",
    "import java.util.stream.Collectors;  \n",
    "  \n",
    "public class StreamFlatMapExample {  \n",
    "    public static void main(String[] args) {  \n",
    "        List<List<String>> listOfLists = Arrays.asList(  \n",
    "            Arrays.asList(\"Apple\", \"Banana\"),  \n",
    "            Arrays.asList(\"Orange\", \"Mango\", \"Peach\"),  \n",
    "            Arrays.asList(\"Grape\", \"Strawberry\")  \n",
    "        );  \n",
    "  \n",
    "        List<String> allFruits = listOfLists.stream()  \n",
    "            .flatMap(List::stream) // 扁平化内部列表  \n",
    "            .collect(Collectors.toList()); // 收集结果到新的List中  \n",
    "  \n",
    "        System.out.println(allFruits); // 输出: [Apple, Banana, Orange, Mango, Peach, Grape, Strawberry]  \n",
    "    }  \n",
    "}\n",
    "\n",
    "StreamFlatMapExample.main(new String[] {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**7. 查找最大值和最小值**  \n",
    "假设你有一个数字列表，你想要找到列表中的最大值和最小值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "import java.util.Arrays;  \n",
    "import java.util.List;  \n",
    "import java.util.Optional;  \n",
    "  \n",
    "public class StreamMinMaxExample {  \n",
    "    public static void main(String[] args) {  \n",
    "        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);  \n",
    "  \n",
    "        Optional<Integer> max = numbers.stream()  \n",
    "            .max(Integer::compare); // 查找最大值  \n",
    "  \n",
    "        Optional<Integer> min = numbers.stream()  \n",
    "            .min(Integer::compare); // 查找最小值  \n",
    "  \n",
    "        max.ifPresent(System.out::println); // 输出最大值，如果有的话  \n",
    "        min.ifPresent(System.out::println); // 输出最小值，如果有的话  \n",
    "        // 输出: 10  \n",
    "        // 输出: 1  \n",
    "    }  \n",
    "}\n",
    "\n",
    "StreamMinMaxExample.main(new String[] {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 方法和构造函数引用(Method and Constructor References) `::` 操作符  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**方法引用是Lambda表达式的一种更简洁的写法，用于直接引用已存在的方法或构造函数。**  \n",
    "\n",
    "在Lambda表达式中，你可能需要显式地声明参数，并在花括号{}中编写方法体。然而，当Lambda表达式的逻辑只是调用一个已经存在的方法时，你可以使用方法引用来代替，从而避免重复编写这些参数和方法体。这种简写方式使得代码更加简洁、易于阅读，并且有时还可以提高性能（尽管这种性能提升通常是微小的，并且依赖于JVM的实现）。  \n",
    "\n",
    "#### `::` 操作符（方法引用）\n",
    "\n",
    "`::` 操作符是Java 8引入的，用于方法引用。**方法引用提供了一种引用已存在方法或构造函数而不执行它的更简洁的方式。** 这主要用于Lambda表达式中，以提供一种更简洁、更易于阅读的方式来传递方法。\n",
    "\n",
    "\n",
    "方法引用通过`::`操作符实现，它主要有四种形式：\n",
    "\n",
    "1. **静态方法引用**：当Lambda表达式只是调用了一个静态方法时，可以使用类名`::`静态方法名来引用该方法。例如，`Arrays::sort`可以视为`(arr, comparator) -> Arrays.sort(arr, comparator)`的简写，但这里需要注意`Arrays::sort`通常与特定的Stream操作结合使用，其实际应用可能更复杂。\n",
    "\n",
    "2. **特定对象的实例方法引用**：当Lambda表达式调用的是特定对象的实例方法时，可以使用`instance::instanceMethod`来引用。例如，`str::length`可以视为`str -> str.length()`的简写。\n",
    "\n",
    "3. **特定类型的任意对象的实例方法引用**：当Lambda表达式需要接收一个对象作为参数，并调用该对象的实例方法时，可以使用`ClassName::instanceMethod`来引用。这里，Lambda表达式的参数会成为方法调用中的隐式参数。例如，`List::size`可以视为`(list) -> list.size()`的简写。\n",
    "\n",
    "4. **构造方法引用**：当Lambda表达式只是简单地调用构造方法时，可以使用`ClassName::new`来引用。例如，`ArrayList::new`可以视为`() -> new ArrayList<>()`的简写（注意这里省略了泛型参数，因为`::new`的语法在Java中不允许直接指定泛型参数，但可以通过类型推断来处理）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 方法引用示例\n",
    "1. 静态方法引用\n",
    "静态方法引用是指向某个类的静态方法。它的语法是：  \n",
    "**ClassName::staticMethodName**  \n",
    "\n",
    "假设有一个 MathUtils 类，其中有一个静态方法 square："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "public class MathUtils {\n",
    "    public static int square(int x) {\n",
    "        return x * x;\n",
    "    }\n",
    "}\n",
    "\n",
    "import java.util.function.IntUnaryOperator;\n",
    "\n",
    "public class MethodReferenceExample {\n",
    "    public static void main(String[] args) {\n",
    "        // IntUnaryOperator是一个函数式接口，它接受一个 int 参数并返回它int类型的的平方;    MathUtils::square 是对 MathUtils 类中静态方法 square 的引用\n",
    "        IntUnaryOperator squareOperator = MathUtils::square;\n",
    "        // IntUnaryOperator squareOperator = x -> MathUtils.square(x);\n",
    "        // 对 MathUtils 类中静态方法 square 的引用\n",
    "        System.out.println(squareOperator.applyAsInt(5));  // 输出 25\n",
    "    }\n",
    "}\n",
    "\n",
    "MethodReferenceExample.main(new String[] {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. 实例方法引用\n",
    "实例方法引用是指向某个对象的实例方法。语法是:  \n",
    "**instance::instanceMethodName**  \n",
    "\n",
    "假设有一个 Person 类，其中有一个实例方法 greet："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "World\n",
      "Java\n",
      "Streams\n"
     ]
    }
   ],
   "source": [
    "import java.util.Arrays;\n",
    "import java.util.List;\n",
    "import java.util.function.Consumer;\n",
    "\n",
    "public class InstanceMethodReferenceExample {\n",
    "    \n",
    "    // 一个简单的类，包含一个实例方法\n",
    "    static class Printer {\n",
    "        public void print(String message) {\n",
    "            System.out.println(message);\n",
    "        }\n",
    "    }\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        // 创建一个 Printer 实例\n",
    "        Printer printer = new Printer();\n",
    "        \n",
    "        // 创建一个字符串列表\n",
    "        List<String> messages = Arrays.asList(\"Hello\", \"World\", \"Java\", \"Streams\");\n",
    "\n",
    "        // 使用实例方法引用来打印每个字符串\n",
    "        // 传递 printer::print 作为 Consumer<String> 的实现\n",
    "        // messages.forEach(printer::print);\n",
    "        messages.forEach(message -> printer.print(message));\n",
    "    }\n",
    "}\n",
    "\n",
    "InstanceMethodReferenceExample.main(new String[] {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. 特定对象的方法引用\n",
    "特定对象的方法引用是指向某个特定对象的实例方法。语法是:  \n",
    "**ClassName::instanceMethodName**  \n",
    "但对象是已知的。\n",
    "\n",
    "假设有一个 Printer 类，其中有一个实例方法 print："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "World\n"
     ]
    }
   ],
   "source": [
    "public class Printer {\n",
    "    public void print(String message) {\n",
    "        System.out.println(message);\n",
    "    }\n",
    "}\n",
    "\n",
    "import java.util.Arrays;\n",
    "import java.util.List;\n",
    "\n",
    "public class MethodReferenceExample {\n",
    "    public static void main(String[] args) {\n",
    "        Printer printer = new Printer();\n",
    "        List<String> messages = Arrays.asList(\"Hello\", \"World\");\n",
    "\n",
    "        // 使用特定对象的方法引用   forEach 方法接受一个 Consumer，并对列表中的每个元素应用 print 方法; printer::print 是对 printer 对象的实例方法 print 的引用\n",
    "        // messages.forEach(printer::print);\n",
    "        messages.forEach(printer::print);\n",
    "    }\n",
    "}\n",
    "\n",
    "MethodReferenceExample.main(new String[] {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. 构造函数引用\n",
    "构造函数引用是指向类的构造函数。语法是:  \n",
    "**ClassName::new**\n",
    "\n",
    "假设有一个 Person 类，其中有一个构造函数："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ClassName::new**\n",
    "\n",
    "假设有一个 Person 类，其中有一个构造函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John\n"
     ]
    }
   ],
   "source": [
    "public class Person {\n",
    "    private String name;\n",
    "\n",
    "    public Person(String name) {\n",
    "        this.name = name;\n",
    "    }\n",
    "\n",
    "    public String getName() {\n",
    "        return name;\n",
    "    }\n",
    "}\n",
    "\n",
    "import java.util.function.Function;\n",
    "\n",
    "public class MethodReferenceExample {\n",
    "    public static void main(String[] args) {\n",
    "        // 使用构造函数引用\n",
    "        // Function<String, Person> 是一个函数式接口，它接受一个 String 参数并返回一个 Person 对象; Person::new 是对 Person 类构造函数的引用\n",
    "        Function<String, Person> personCreator = Person::new;\n",
    "        // Function<String, Person> personCreator = name -> new Person(name);\n",
    "        Person person = personCreator.apply(\"John\");\n",
    "        System.out.println(person.getName());  // 输出 \"John\"\n",
    "    }\n",
    "}\n",
    "\n",
    "MethodReferenceExample.main(new String[] {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 补充： `.` 操作符\n",
    "\n",
    "在Java中，`::` 操作符和 `.` 操作符是两种非常不同但各自在特定上下文中非常重要的操作符。\n",
    "\n",
    "`.` 操作符是Java中的成员访问操作符。它用于访问对象的字段（变量）和方法。当你有一个对象引用，并且想要访问该对象的某个字段或调用其某个方法时，你会使用 `.` 操作符。\n",
    "\n",
    "例如，如果你有一个`String`对象`str`，你可以使用`str.length()`来调用其`length()`方法，或者使用`str.charAt(0)`来访问其第一个字符。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "java",
   "pygments_lexer": "java",
   "version": "17.0.11+7-LTS-207"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
